home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1994 / MacHack 1994.toast / MacHack™ 1987-1994 / MacHack™ '93 / Papers '93 / Macintosh as Internet Server ƒ / inetd / Libraries / DaemonApp / UFailure.cp < prev    next >
Encoding:
Text File  |  1993-04-07  |  7.5 KB  |  330 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. //UFailure.cp
  3. //Copyright © 1985-1992 Apple Computer, Inc.  All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UFAILURE__
  7. #include "UFailure.h"
  8. #endif
  9.  
  10. #ifndef __STDIO__
  11. #include <StdIo.h>
  12. #endif
  13.  
  14. #ifndef __MEMORY__
  15. #include <Memory.h>
  16. #endif
  17.  
  18. #ifndef __RESOURCES__
  19. #include <Resources.h>
  20. #endif
  21.  
  22. #ifndef __ERRORS__
  23. #include <Errors.h>
  24. #endif
  25.  
  26. #ifdef NEVER
  27. #ifndef __UMACAPPUTILITIES__
  28. #include "UMacAppUtilities.h"
  29. #endif
  30.  
  31. #ifndef __UDEBUG__
  32. #include "UDebug.h"
  33. #endif
  34. #endif NEVER
  35.  
  36. FailInfoPtr gTopHandler = NULL;
  37.  
  38. #if qDebug
  39. #ifdef NEVER
  40. MAName pWho;                                    // used serially. Avoids putting it on stack
  41. #endif
  42. #endif
  43.  
  44. extern pascal void DoFailure(FailInfoPtr pf);
  45.  
  46. //----------------------------------------------------------------------------------------
  47. // Assertion: 
  48. //----------------------------------------------------------------------------------------
  49. #pragma segment MAFailureRes
  50.  
  51. pascal void Assertion(const Boolean condition,
  52.                       const CStr255& 
  53. #if qDebug
  54.                                      description
  55. #endif
  56.                                                 )
  57. {
  58.     if (!condition)
  59.     {
  60. #if qDebug
  61. #ifdef NEVER
  62.         GetCallersMethodName(pWho);
  63.         fprintf(stderr, "Assertion failed in " + pWho + ": " + description);
  64. #else        
  65.         CStr255 str = "Assertion failed: " + description;
  66.         DebugStr(str); 
  67. #endif
  68. #endif
  69.         Failure(minErr, 0);
  70.     }
  71. } // Assertion 
  72.  
  73. //----------------------------------------------------------------------------------------
  74. // EachFailureHandlerDo: 
  75. //----------------------------------------------------------------------------------------
  76. #pragma segment MAFailureRes
  77.  
  78. pascal void EachFailureHandlerDo(DoToHandlerType DoToHandler,
  79.                                  void* staticLink)
  80. {
  81.     for (FailInfoPtr pf = gTopHandler; (pf); pf = pf->nextInfo)
  82.         (*DoToHandler)(pf, staticLink);
  83. } // EachFailureHandlerDo 
  84.  
  85. //----------------------------------------------------------------------------------------
  86. // FailMemError: 
  87. //----------------------------------------------------------------------------------------
  88. #pragma segment MAFailureRes
  89.  
  90. pascal void FailMemError()
  91. {
  92.     OSErr e = MemError();
  93.  
  94.     if (e != noErr)
  95.         Failure(e, 0);
  96. } // FailMemError 
  97.  
  98. //----------------------------------------------------------------------------------------
  99. // FailNewMessage: 
  100. //----------------------------------------------------------------------------------------
  101. #pragma segment MAFailureRes
  102.  
  103. pascal void FailNewMessage(short error,
  104.                            long oldMessage,
  105.                            long newMessage)
  106. {
  107.     if (!oldMessage)
  108.         Failure(error, newMessage);
  109.     else
  110.         Failure(error, oldMessage);
  111. } // FailNewMessage 
  112.  
  113. //----------------------------------------------------------------------------------------
  114. // FailNIL: 
  115. //----------------------------------------------------------------------------------------
  116. #pragma segment MAFailureRes
  117.  
  118. pascal void FailNIL(void* p)
  119. {
  120.     if (!p)
  121.         Failure(memFullErr, 0);
  122. } // FailNIL 
  123.  
  124. //----------------------------------------------------------------------------------------
  125. // FailNILResource: 
  126. //----------------------------------------------------------------------------------------
  127. #pragma segment MAFailureRes
  128.  
  129. pascal void FailNILResource(Handle r)
  130. {
  131.     OSErr e;
  132.  
  133.     if (!r)
  134.     {
  135.         e = ResError();
  136.         if (e == noErr)
  137.             e = resNotFound;
  138.         Failure(e, 0);
  139.     }
  140. } // FailNILResource 
  141.  
  142. //----------------------------------------------------------------------------------------
  143. // FailOSErr: 
  144. //----------------------------------------------------------------------------------------
  145. #pragma segment MAFailureRes
  146.  
  147. pascal void FailOSErr(short error)
  148. {
  149.     if (error != noErr)
  150.         Failure(error, 0);
  151. } // FailOSErr 
  152.  
  153. //----------------------------------------------------------------------------------------
  154. // FailResError: 
  155. //----------------------------------------------------------------------------------------
  156. #pragma segment MAFailureRes
  157.  
  158. pascal void FailResError()
  159.  
  160. {
  161.     OSErr e = ResError();
  162.  
  163.     if (e != noErr)
  164.         Failure(e, 0);
  165. } // FailResError 
  166.  
  167. //----------------------------------------------------------------------------------------
  168. // Failure: 
  169. //----------------------------------------------------------------------------------------
  170. #pragma segment MAFailureRes
  171.  
  172. pascal void Failure(short error,
  173.                     long message)
  174.  
  175. {
  176.     FailInfoPtr pf = gTopHandler;
  177. #if qDebug
  178. #ifdef NEVER
  179.     long pc;
  180. #endif
  181. #endif
  182.  
  183.     if (pf)
  184.     {
  185.         // pop the stack first, because calling the handler is likely to result in a call
  186.         // to Failure
  187.         gTopHandler = pf->nextInfo;
  188.  
  189. #if qDebug
  190.         pf->installed = FALSE;
  191. #ifdef NEVER
  192.         if (CanWriteLn() && ((error != 0) || gIntenseDebugging))// only show 0 errors if _really_ looking
  193.         {
  194.             GetCallersMethodName(pWho);
  195.             fprintf(stderr, "Failure signaled by: %s\n", (char *) pWho);
  196.             pc = pf->whoPC;
  197.             GetMethodName((void *) pc, pWho);
  198.  
  199.             fprintf(stderr, "Failure caught by: %s\n", (char *) pWho);
  200.             fprintf(stderr, "        error: %1d message: %1d (%1d/%1d)\n", error, message, message >> 16, message & 0x0000FFFF);
  201.         }
  202. #else 
  203.         char    str[255];
  204.         sprintf(str, "Failure params: error = %d, message = %d", error, message);
  205.         DebugStr(CStr255(str));
  206. #endif 
  207. #endif qDebug
  208.  
  209.         pf->error = error;
  210.         pf->message = message;
  211.         DoFailure(pf);                            // Go execute the failure handler
  212.     }
  213.     else
  214.     {
  215.         if (qDebug)
  216.             ProgramBreak("Failure called, but no handler!");
  217.     }
  218. } // Failure 
  219.  
  220. //----------------------------------------------------------------------------------------
  221. // ProgramBreak: 
  222. //----------------------------------------------------------------------------------------
  223. #pragma segment MAFailureRes
  224.  
  225. pascal void ProgramBreak(const CStr255& grievance)
  226. {
  227.     CStr255 report = grievance + "\n";
  228.  
  229. #if qDebug
  230. #ifdef NEVER
  231.     ConfirmHighLevelDebugger();
  232.     
  233.     if (gHighLevelDebuggerRunning)
  234.         SysBreakStr(report);
  235.     else
  236. #endif
  237.         DebugStr(report);
  238. #else
  239.     DebugStr(report);
  240. #endif
  241.  
  242. } // ProgramBreak 
  243.  
  244. //----------------------------------------------------------------------------------------
  245. // ProgramReport: 
  246. //----------------------------------------------------------------------------------------
  247. #pragma segment MAFailureRes
  248.  
  249. pascal void ProgramReport(const CStr255& grievance,
  250.                           const Boolean
  251. #if qDebug
  252. #ifdef NEVER
  253. breakInDebugger
  254. #endif
  255. #endif
  256. )
  257.  
  258. {
  259.     CStr255 report = grievance + "\n";
  260.  
  261. #if qDebug
  262. #ifdef NEVER
  263.     ConfirmHighLevelDebugger();
  264.     
  265.     if (gHighLevelDebuggerRunning)
  266.     {
  267.         if (breakInDebugger)
  268.             SysBreakStr(report);
  269.         else
  270.             SysBreakFunc(report);
  271.     }
  272.     else
  273. #endif
  274.         DebugStr(report);
  275. #else
  276.     DebugStr(report);
  277. #endif
  278.  
  279. } // ProgramReport 
  280.  
  281. //----------------------------------------------------------------------------------------
  282. // HandlerExists: 
  283. //----------------------------------------------------------------------------------------
  284. #pragma segment MAFailureRes
  285.  
  286. pascal Boolean HandlerExists(FailInfoPtr testFailInfoPtr)
  287. {
  288.     FailInfoPtr pf = gTopHandler;
  289.  
  290.     while (pf)
  291.     {
  292.         if (pf == testFailInfoPtr)
  293.             return TRUE;
  294.         pf = pf->nextInfo;
  295.     }
  296.     return FALSE;
  297. } // HandlerExists 
  298.  
  299. //----------------------------------------------------------------------------------------
  300. // Success: 
  301. //----------------------------------------------------------------------------------------
  302. #pragma segment MAFailureRes
  303.  
  304. pascal void Success(FailInfo& fi)
  305. {
  306. #if qDebug
  307.     if (gTopHandler != &fi)
  308.     {
  309.         CStr255 msg;
  310. #ifdef NEVER
  311.         fprintf(stderr, "gTopHandler: %p, parameter: %p\n", gTopHandler, &fi);
  312. #endif
  313.         msg = "Problem with Success: ";
  314.         if (HandlerExists(&fi))
  315.             msg += "too few ";
  316.         else
  317.             msg += "too many ";
  318.         msg += "calls to Success";
  319.         ProgramBreak(msg);
  320.     }
  321.  
  322.     fi.installed = FALSE;
  323. #endif
  324.  
  325.     gTopHandler = fi.nextInfo;
  326. } // Success 
  327.  
  328.  
  329.  
  330.